package com.zxgj.datadirect.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zxgj.datadirect.domain.DataDirectExchangeTask;
import com.zxgj.datadirect.dto.ExchangeTaskCreateReq;
import com.zxgj.datadirect.dto.ExchangeTaskLogResp;
import com.zxgj.datadirect.entity.DataDirectExchangeTaskLog;
import com.zxgj.datadirect.entity.resp.CommonResp;
import com.zxgj.datadirect.mapper.DataDirectExchangeTaskLogMapper;
import com.zxgj.datadirect.mapper.DataDirectExchangeTaskMapper;
import com.zxgj.datadirect.service.DataDirectExchangeTaskService;
import com.zxgj.common.exception.ServiceException;
import com.zxgj.common.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 数据直通交换任务服务实现类
 * 提供数据交换任务的增删改查及执行控制功能
 */
@Slf4j
@Service
public class DataDirectExchangeTaskServiceImpl implements DataDirectExchangeTaskService {

    /**
     * 数据直通交换任务Mapper接口
     */
    private final DataDirectExchangeTaskMapper taskMapper;
    
    /**
     * 数据直通交换任务日志Mapper接口
     */
    private final DataDirectExchangeTaskLogMapper taskLogMapper;

    /**
     * 构造函数注入Mapper
     * @param taskMapper 数据直通交换任务Mapper
     * @param taskLogMapper 数据直通交换任务日志Mapper
     */
    public DataDirectExchangeTaskServiceImpl(DataDirectExchangeTaskMapper taskMapper, DataDirectExchangeTaskLogMapper taskLogMapper) {
        this.taskMapper = taskMapper;
        this.taskLogMapper = taskLogMapper;
    }

    /**
     * 创建数据交换任务
     * @param task 待创建的数据交换任务对象
     * @return CommonResp<DataDirectExchangeTask> 通用响应对象，包含创建成功的任务信息
     */
    @Override
    @Transactional
    public CommonResp<DataDirectExchangeTask> createTask(DataDirectExchangeTask task) {
        try {
            taskMapper.insert(task); // MyBatis-Plus 语法，或自定义 insert 语句
            return CommonResp.success(task);
        } catch (Exception e) {
            log.error("创建任务失败:", e);
            return CommonResp.fail("任务创建失败");
        }
    }

    /**
     * 根据状态查询任务列表
     * @param status 任务状态
     * @return CommonResp<List<DataDirectExchangeTask>> 通用响应对象，包含符合条件的任务列表
     */
    @Override
    public CommonResp<List<DataDirectExchangeTask>> listTasks(String status) {
        List<DataDirectExchangeTask> tasks = taskMapper.selectByStatus(status);
        return CommonResp.success(tasks);
    }

    /**
     * 执行数据交换任务
     * @param taskId 任务ID
     * @return CommonResp<Boolean> 通用响应对象，包含执行结果
     */
    @Override
    @Transactional
    public CommonResp<Boolean> executeExchange(Long taskId) {
        // 根据任务ID查询任务信息
        DataDirectExchangeTask task = taskMapper.selectById(taskId);
        if (task == null) {
            return CommonResp.fail("任务不存在");
        }
        try {
            // 1. 业务校验（如任务状态是否允许执行）
            if (task.getTaskStatus() != null && task.getTaskStatus() != 0) {
                return CommonResp.fail("任务状态不允许执行");
            }
            // 2. 执行数据交换逻辑（调用 Feign、Mapper 等）
            task.setTaskStatus(1); // 设置为运行中
            taskMapper.updateById(task);

            // 3. 执行数据交换逻辑
            //    实际项目中应该调用底层接口/存储过程
            //    可通过 NationalDataDirectFeign 调用其他服务
            //    或通过 DataDirectResourceMapper 操作数据库
            
            // 模拟数据交换处理时间
            Thread.sleep(1000);
            
            // 这里应该根据实际业务需求实现具体的数据交换逻辑
            // 例如：调用外部API、执行存储过程、数据转换等

            task.setTaskStatus(3); // 设置为已完成
            taskMapper.updateById(task);
            return CommonResp.success(true);
        } catch (Exception e) {
            task.setTaskStatus(4); // 设置为失败
            taskMapper.updateById(task);
            log.error("执行任务失败:", e);
            return CommonResp.fail("数据交换失败");
        }
    }

    /**
     * 取消数据交换任务
     * @param taskId 任务ID
     * @return CommonResp<Boolean> 通用响应对象，包含取消结果
     */
    @Override
    @Transactional
    public CommonResp<Boolean> cancelTask(Long taskId) {
        // 根据任务ID查询任务信息
        DataDirectExchangeTask task = taskMapper.selectById(taskId);
        if (task == null) {
            return CommonResp.fail("任务不存在");
        }
        // 校验任务状态，执行中的任务不能取消
        if (task.getTaskStatus() != null && task.getTaskStatus() == 1) {
            return CommonResp.fail("任务执行中，无法取消");
        }
        // 更新任务状态为已停止
        task.setTaskStatus(2);
        taskMapper.updateById(task);
        return CommonResp.success(true);
    }

    /**
     * 创建交换任务
     * @param req 交换任务创建请求参数
     * @return Long 任务ID
     */
    @Override
    @Transactional
    public Long createExchangeTask(ExchangeTaskCreateReq req) {
        if (req == null) {
            throw new ServiceException("请求参数不能为空");
        }
        
        // 参数校验
        if (StringUtils.isEmpty(req.getTaskName())) {
            throw new ServiceException("任务名称不能为空");
        }
        if (StringUtils.isEmpty(req.getSourceSystem())) {
            throw new ServiceException("源系统不能为空");
        }
        if (StringUtils.isEmpty(req.getTargetSystem())) {
            throw new ServiceException("目标系统不能为空");
        }
        
        // 创建交换任务实体
        DataDirectExchangeTask task = new DataDirectExchangeTask();
        task.setTaskName(req.getTaskName());
        task.setSourceSystem(req.getSourceSystem());
        task.setTargetSystem(req.getTargetSystem());
        task.setExchangeType(req.getExchangeType());
        task.setTaskStatus(0); // 初始状态：待启动
        task.setCreateTime(new Date());
        task.setUpdateTime(new Date());
        
        // 设置其他参数
        if (req.getStartTime() != null) {
            task.setStartTime(req.getStartTime());
        }
        if (req.getEndTime() != null) {
            task.setEndTime(req.getEndTime());
        }
        if (StringUtils.isNotEmpty(req.getTaskDesc())) {
            task.setTaskDesc(req.getTaskDesc());
        }
        if (StringUtils.isNotEmpty(req.getDataFormat())) {
            task.setDataFormat(req.getDataFormat());
        }
        if (StringUtils.isNotEmpty(req.getExchangeFrequency())) {
            task.setExchangeFrequency(req.getExchangeFrequency());
        }
        
        // 保存到数据库
        taskMapper.insert(task);
        
        log.info("创建交换任务成功，任务ID: {}, 任务名称: {}", task.getId(), task.getTaskName());
        return task.getId();
    }

    /**
     * 控制交换任务
     * @param taskId 任务ID
     * @param operateType 操作类型（1-启动、2-暂停、3-停止、4-重启）
     * @param req 交换任务创建请求参数
     * @return boolean 控制结果
     */
    @Override
    @Transactional
    public boolean controlExchangeTask(Long taskId, Integer operateType, ExchangeTaskCreateReq req) {
        if (taskId == null) {
            throw new ServiceException("任务ID不能为空");
        }
        if (operateType == null) {
            throw new ServiceException("操作类型不能为空");
        }
        
        // 查询任务信息
        DataDirectExchangeTask task = taskMapper.selectById(taskId);
        if (task == null) {
            throw new ServiceException("任务不存在");
        }
        
        boolean result = false;
        switch (operateType) {
            case 1: // 启动任务
                if (task.getTaskStatus() != null && (task.getTaskStatus() == 0 || task.getTaskStatus() == 2)) {
                    task.setTaskStatus(1); // 设置为运行中
                    task.setUpdateTime(new Date());
                    result = taskMapper.updateById(task) > 0;
                    log.info("启动交换任务成功，任务ID: {}", taskId);
                } else {
                    throw new ServiceException("任务状态不允许启动");
                }
                break;
            case 2: // 暂停任务
                if (task.getTaskStatus() != null && task.getTaskStatus() == 1) {
                    task.setTaskStatus(2); // 设置为已停止
                    task.setUpdateTime(new Date());
                    result = taskMapper.updateById(task) > 0;
                    log.info("暂停交换任务成功，任务ID: {}", taskId);
                } else {
                    throw new ServiceException("任务状态不允许暂停");
                }
                break;
            case 3: // 停止任务
                task.setTaskStatus(2); // 设置为已停止
                task.setUpdateTime(new Date());
                result = taskMapper.updateById(task) > 0;
                log.info("停止交换任务成功，任务ID: {}", taskId);
                break;
            case 4: // 重启任务
                if (task.getTaskStatus() != null && (task.getTaskStatus() == 4 || task.getTaskStatus() == 2)) {
                    task.setTaskStatus(0); // 设置为待启动
                    task.setUpdateTime(new Date());
                    result = taskMapper.updateById(task) > 0;
                    log.info("重启交换任务成功，任务ID: {}", taskId);
                } else {
                    throw new ServiceException("任务状态不允许重启");
                }
                break;
            default:
                throw new ServiceException("不支持的操作类型");
        }
        
        return result;
    }

    /**
     * 根据条件查询交换任务列表
     * @param wrapper 查询条件包装器
     * @return List<DataDirectExchangeTask> 任务列表
     */
    @Override
    public List<DataDirectExchangeTask> list(LambdaQueryWrapper<DataDirectExchangeTask> wrapper) {
        if (wrapper == null) {
            // 如果没有查询条件，返回所有任务
            return taskMapper.selectList(null);
        }
        return taskMapper.selectList(wrapper);
    }

    /**
     * 获取交换任务日志
     * @param taskId 任务ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return List<ExchangeTaskLogResp> 任务日志列表
     */
    @Override
    public List<ExchangeTaskLogResp> getExchangeTaskLogs(Long taskId, String startTime, String endTime) {
        if (taskId == null) {
            throw new ServiceException("任务ID不能为空");
        }
        
        // 构建查询条件
        LambdaQueryWrapper<DataDirectExchangeTaskLog> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(DataDirectExchangeTaskLog::getTaskId, taskId);
        
        // 添加时间范围查询
        if (StringUtils.isNotEmpty(startTime)) {
            wrapper.ge(DataDirectExchangeTaskLog::getCreateTime, startTime);
        }
        if (StringUtils.isNotEmpty(endTime)) {
            wrapper.le(DataDirectExchangeTaskLog::getCreateTime, endTime);
        }
        
        // 按创建时间倒序排列
        wrapper.orderByDesc(DataDirectExchangeTaskLog::getCreateTime);
        
        // 查询日志记录
        List<DataDirectExchangeTaskLog> logs = taskLogMapper.selectList(wrapper);
        
        // 转换为响应对象
        List<ExchangeTaskLogResp> result = new ArrayList<>();
        for (DataDirectExchangeTaskLog log : logs) {
            ExchangeTaskLogResp resp = new ExchangeTaskLogResp();
            resp.setLogId(log.getId());
            resp.setTaskId(log.getTaskId());
            resp.setContent(log.getContent());
            resp.setLevel(log.getLevel());
            resp.setOperateTime(log.getOperateTime());
            resp.setCreateTime(log.getCreateTime());
            resp.setOperator(log.getOperator());
            resp.setResult(log.getResult());
            resp.setErrorMessage(log.getErrorMessage());
            resp.setExecutionTime(log.getExecutionTime());
            result.add(resp);
        }
        
        return result;
    }
}
